﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using StockholmsStad.Business;
using StockholmsStad.Utilities.Exceptions;
using StockholmsStad.Runtime.Serialization.DataContract;
using StockholmsStad.ServiceModel.Interfaces;
using StockholmsStad.Runtime.Serialization.DataContract.Enums;

namespace StockholmsStad.ServiceModel.Services
{
    /// <summary>
    /// Detta är serviceimplementationsklassen för servicen IWinService.
    /// </summary>
    public class WinService : IWinService
    {
        #region IWinService Members

        /// <summary>
        /// Implementation av operationskontrakt som hämtar alla ceremonispråk.
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <returns>En lista av typen <see cref="ValueIdPair"/> med ceremonispråk eller tom lista om inga språk finns.</returns>
        public IList<ValueIdPair> GetCeremonyLanguages(User user)
        {
            try
            {
                return new CeremonyBusiness(user).GetCeremonyLanguages();
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontrakt som hämtar alla certifikatspråk.
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <returns>En lista av typen <see cref="ValueIdPair"/> med certifikatspråk eller tom lista om inga språk finns.</returns>
        public IList<ValueIdPair> GetCertificateLanguages(User user)
        {
            try
            {
                return new CeremonyBusiness(user).GetCertificateLanguages();
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontrakt för att hämta aktuellt standardspråk
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <returns>Standardspråket eller tom sträng om inget sådant finns angivet</returns>
        public ValueIdPair GetDefaultLanguage(User user)
        {
            try
            {
                return new CeremonyBusiness(user).GetDefaultLangauage();
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontrakt som hämtar alla hjälpmedel.
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <returns>En lista av typen <see cref="ValueIdPair"/> med hjälpmedel eller tom lista om inga hjälpmedel finns.</returns>
        public IList<ValueIdPair> GetCeremonySpecialNeeds(User user)
        {
            try
            {
                return new CeremonyBusiness(user).GetCeremonySpecialNeeds();
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontrakt som hämtar alla ceremonityper.
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <returns>En lista av typen <see cref="ValueIdPair"/> med certifikatspråk eller tom lista om inga språk finns.</returns>
        public IList<ValueIdPair> GetCeremonyTypes(User user)
        {
            try
            {
                return new CeremonyBusiness(user).GetCeremonyTypes();
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontrakt för modifering av befintligt förrättare.
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="minister">Förrättaren (<see cref="Minister"/>) som ska uppdateras.</param>
        public void UpdateMinister(User user, Minister minister)
        {
            try
            {
                var ministerBusiness = new MinisterBusiness(user);
                ministerBusiness.UpdateMinister(minister);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontraktet för att lägga till en ny förrättare
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="minister">Förrättaren (<see cref="Minister"/>) som ska uppdateras.</param>
        /// <returns>Det erhållna förrättarid-numret</returns>
        public int AddMinister(User user, Minister minister)
        {
            try
            {
                var ministerBusiness = new MinisterBusiness(user);
                return ministerBusiness.AddMinister(minister);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="user"></param>
        /// <param name="ministerId"></param>
        /// <returns></returns>
        public Minister GetMinister(User user, int ministerId)
        {
            try
            {
                return new MinisterBusiness(user).GetMinister(ministerId);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontraktet som hämtar alla förrättare
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <returns>En lista med förrättare <see cref="Minister"/> eller en tom lista om inga förrättare finns.</returns>
        public IList<Minister> GetMinisters(User user)
        {
            try
            {
                return new MinisterBusiness(user).GetMinisters().ToList();
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontraktet som hämtar alla förrättare som är verksamma inom ett angivet intervall.
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="date">Det datum då förrättaren ska vara verksam.</param>
        /// <returns>En lista med förrättare <see cref="Minister"/> som är verksamma inom den givna perioden eller en tom 
        /// lista om inga förrättare finns.</returns>
        public IList<Minister> GetMinistersForPeriod(User user, DateTime date)
        {
            try
            {
                return new MinisterBusiness(user).GetMinisters(date).ToList();
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontraktet som hämtar alla tidsblock.
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <returns>En lista med tidsblock <see cref="MinisterTimeBlock"/> som är verksamma inom den givna perioden eller en 
        /// tom lista om inga förrättare finns.</returns>
        public IList<MinisterTimeBlock> GetTimeBlocks(User user)
        {
            try
            {
                return new MaintenanceBusiness(user).GetTimeBlocks().ToList();
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontraktet som uppdaterar alla tidsblock, om inte tidsblocket finns så läggs det till. 
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="timeBlocks">En lista med tidsblock (<see cref="MinisterTimeBlock"/>) som ska läggas till.</param>
        /// <returns>En lista med de uppdaterade tidsblocken <see cref="MinisterTimeBlock"/> som är verksamma inom den givna perioden eller en 
        /// tom lista om inga förrättare finns.</returns>
        public IList<MinisterTimeBlock> UpdateTimeBlocks(User user, List<MinisterTimeBlock> timeBlocks)
        {
            try
            {
                return new MaintenanceBusiness(user).UpdateTimeBlocks(timeBlocks);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontraktet som hämtar tidsblock för ett givet datum. 
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="date">Det datum för vilka tidsblock (<see cref="MinisterTimeBlock"/>) ska hämtas.</param>
        /// <returns>En lista med de aktuella tidsblocken <see cref="MinisterTimeBlock"/>.</returns>
        public IList<MinisterTimeBlock> GetTimeBlocksForDate(User user, DateTime date)
        {
            try
            {
                return new MaintenanceBusiness(user).GetTimeBlocks(date);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Operationskontrakt för att hämta tidsblock för en förrättare. 
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="ministerId">Id på den förrättare som tider ska hämtas för. </param>
        public List<MinisterTimeBlock> GetTimeBlocksForMinister(User user, int ministerId)
        {
            try
            {
                return new MinisterBusiness(user).GetTimeBlockForMinister(ministerId).ToList();
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Operationskontrakt för att lägga till en användare. 
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="addedUser">Användarinformation om den nya användaren</param>
        public int AddUser(User user, ParvisUser addedUser)
        {
            try
            {
                return new UserBusiness(user).AddUser(addedUser);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Autentisering av användare mot systemet. 
        /// </summary>
        /// <param name="user">Användaren som försöker logga in. </param>
        /// <returns>Behörig användare med dess roll, annars null. </returns>
        public User Login(User user)
        {
            try
            {
                return new UserBusiness(user).Login();
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Avaktiverar en användare i systemet. 
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="username">Användarnamnet på den person som ska avaktiveras. </param>
        public void SetUserInactive(User user, string username)
        {
            try
            {
                new UserBusiness(user).SetUserInactive(username);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Hämtar alla användarroller. 
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <returns>En lista med alla roller. </returns>
        public List<UserRole> GetRoles(User user)
        {
            try
            {
                return new UserBusiness(user).GetRoles();
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Hämtar alla användarroller. 
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="includeInactiveUsers">Inkludera även inaktiva användare.</param>
        /// <returns>En lista med alla roller. </returns>
        public List<ParvisUser> GetUsers(User user, bool includeInactiveUsers)
        {
            try
            {
                return new UserBusiness(user).GetUsers(includeInactiveUsers);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Hämtar en användare i systemet. 
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="parvisUserId">Användarens id. </param>
        /// <returns>Användaren (<see cref="ParvisUser"/>).</returns>
        public ParvisUser GetParvisUser(User user, int parvisUserId)
        {
            try
            {
                return new UserBusiness(user).GetParvisUser(parvisUserId);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="user"></param>
        /// <param name="ceremony"></param>
        /// <param name="ticketId"></param>
        public void UpdateCeremony(User user, Ceremony ceremony, int ticketId)
        {
            try
            {
                var cb = new CeremonyBusiness(user);
                cb.UpdateCeremony(ceremony, ticketId);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Hämtar alla användarroller. 
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="updatedUser">Den användaren som ska uppdateras (<see cref="ParvisUser"/>).</param>
        /// <returns>En lista med alla roller. </returns>
        public void UpdateUser(User user, ParvisUser updatedUser)
        {
            try
            {
                var ub = new UserBusiness(user);
                ub.UpdateUser(updatedUser);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontraktet för att hämta en bokning för ett
        /// aktuellt ärende
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="ticketId">Nyckeln på det ärende som avses. </param>
        /// <returns>Bokningen, eller null om ingen bokning finns. </returns>
        public Booking GetBooking(User user, int ticketId)
        {
            try
            {
                return new BookingBusiness(user).GetBooking(ticketId);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontraktet för att spara en bokning till ett befintligt ärende
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="ticketId">Nyckeln på det ärende som avses. </param>
        /// <param name="booking">Den bokning (<see cref="Booking"/>) som ska sparas. </param>
        /// <returns>Bokningen, eller null om ingen bokning finns. </returns>
        public void SaveBooking(User user, int ticketId, Booking booking)
        {
            try
            {
                var bookingBusiness = new BookingBusiness(user);
                bookingBusiness.SaveBooking(ticketId, booking);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontraktet för att avboka en befintlig bokning för ett ärende
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="ticketId">Nyckeln på det ärende som avses. </param>
        /// <returns>Bokningen, eller null om ingen bokning finns. </returns>
        public void CancelBooking(User user, int ticketId)
        {
            try
            {
                var bookingBusiness = new BookingBusiness(user);
                bookingBusiness.CancelBooking(ticketId);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Hämtar historiken för ett ärende
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="ticketId">Ärendet som historiken som hämtas för. </param>
        /// <returns>En lista med historik (<see cref="History"/>).</returns>
        public IList<History> GetHistory(User user, int ticketId)
        {
            try
            {
                return new TicketBusiness(user).GetHistory(ticketId).ToList();
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }


        /// <summary>
        /// Implementation av operationskontraktet för att hämta lediga tidsblock. 
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <returns>Listan med lediga tidsblock (<see cref="TimeBlock"/>). </returns>
        public IList<TimeBlock> GetFreeTimeBlocks(User user)
        {
            try
            {
                var bookingBusiness = new BookingBusiness(user);
                return bookingBusiness.GetFreeTimeBlockDateTimes(false, false);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// Implementation av operationskontraktet för att hämta information om ceremoni för ett 
        /// visst ärende. 
        /// </summary>
        /// <param name="user">Den inloggade användaren (<see cref="User"/>).</param>
        /// <param name="ticketId">Ärende-numret för den ceremoniinformation som ska hämtas</param>
        /// <returns>Ceremoniinformationen (<see cref="CeremonyBooking"/>).</returns>
        public CeremonyBooking GetCeremony(User user, int ticketId)
        {
            try
            {
                var ticketBusiness = new TicketBusiness(user);
                return ticketBusiness.GetCeremony(ticketId);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="user"></param>
        /// <param name="coupleId"></param>
        /// <param name="ticketStatusType"></param>
        public void UpdateTicketStatus(User user, int coupleId, TicketStatusType ticketStatusType)
        {
            try
            {
                var ticketBusiness = new TicketBusiness(user);
                ticketBusiness.UpdateTicketStatus(coupleId, ticketStatusType);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="user"></param>
        /// <param name="ministerId"></param>
        /// <param name="date"></param>
        /// <returns></returns>
        public bool HasMinisterAnyServices(User user, int ministerId, DateTime date)
        {
            try
            {
                var ministerBusiness = new MinisterBusiness(user);
                return ministerBusiness.HasMinisterAnyServices(ministerId, date);
            }
            catch (StockholmStadSystemException e)
            {
                throw new FaultException<StockholmStadSystemErrorFault>(new StockholmStadSystemErrorFault(e.ErrorCode, e.Message));
            }
            catch (StockholmStadApplicationException e)
            {
                throw new FaultException<StockholmStadApplicationErrorFault>(new StockholmStadApplicationErrorFault(e.ErrorCode, e.Message));
            }
        }

        #endregion
    }
}
